/**
 * 内存管理工具类
 * 用于统一管理组件内存清理，防止内存泄漏
 */
export class MemoryManager {
  constructor() {
    this.eventListeners = new Map();
    this.timers = new Set();
    this.intervals = new Set();
    this.observers = new Set();
    this.dataRefs = new Map();
  }

  /**
   * 添加事件监听器并记录
   * @param {Element|Window} target 目标元素
   * @param {string} event 事件名
   * @param {Function} handler 处理函数
   * @param {Object} options 选项
   */
  addEventListener(target, event, handler, options = {}) {
    const key = `${target === window ? 'window' : target.constructor.name}_${event}`;
    
    if (!this.eventListeners.has(key)) {
      this.eventListeners.set(key, []);
    }
    
    this.eventListeners.get(key).push({ target, event, handler, options });
    target.addEventListener(event, handler, options);
  }

  /**
   * 移除事件监听器
   * @param {Element|Window} target 目标元素
   * @param {string} event 事件名
   * @param {Function} handler 处理函数
   */
  removeEventListener(target, event, handler) {
    const key = `${target === window ? 'window' : target.constructor.name}_${event}`;
    
    if (this.eventListeners.has(key)) {
      const listeners = this.eventListeners.get(key);
      const index = listeners.findIndex(l => 
        l.target === target && l.event === event && l.handler === handler
      );
      
      if (index > -1) {
        listeners.splice(index, 1);
        target.removeEventListener(event, handler);
        
        if (listeners.length === 0) {
          this.eventListeners.delete(key);
        }
      }
    }
  }

  /**
   * 添加定时器并记录
   * @param {Function} callback 回调函数
   * @param {number} delay 延迟时间
   * @returns {number} 定时器ID
   */
  addTimeout(callback, delay) {
    const timerId = setTimeout(() => {
      this.timers.delete(timerId);
      callback();
    }, delay);
    
    this.timers.add(timerId);
    return timerId;
  }

  /**
   * 添加间隔器并记录
   * @param {Function} callback 回调函数
   * @param {number} interval 间隔时间
   * @returns {number} 间隔器ID
   */
  addInterval(callback, interval) {
    const intervalId = setInterval(callback, interval);
    this.intervals.add(intervalId);
    return intervalId;
  }

  /**
   * 清除定时器
   * @param {number} timerId 定时器ID
   */
  clearTimeout(timerId) {
    if (this.timers.has(timerId)) {
      clearTimeout(timerId);
      this.timers.delete(timerId);
    }
  }

  /**
   * 清除间隔器
   * @param {number} intervalId 间隔器ID
   */
  clearInterval(intervalId) {
    if (this.intervals.has(intervalId)) {
      clearInterval(intervalId);
      this.intervals.delete(intervalId);
    }
  }

  /**
   * 添加数据引用
   * @param {string} key 键名
   * @param {*} value 值
   */
  addDataRef(key, value) {
    this.dataRefs.set(key, value);
  }

  /**
   * 获取数据引用
   * @param {string} key 键名
   * @returns {*} 值
   */
  getDataRef(key) {
    return this.dataRefs.get(key);
  }

  /**
   * 清理所有资源
   */
  cleanup() {
    // 清理所有事件监听器
    this.eventListeners.forEach((listeners, key) => {
      listeners.forEach(({ target, event, handler }) => {
        target.removeEventListener(event, handler);
      });
    });
    this.eventListeners.clear();

    // 清理所有定时器
    this.timers.forEach(timerId => {
      clearTimeout(timerId);
    });
    this.timers.clear();

    // 清理所有间隔器
    this.intervals.forEach(intervalId => {
      clearInterval(intervalId);
    });
    this.intervals.clear();

    // 清理所有观察器
    this.observers.forEach(observer => {
      if (observer.disconnect) {
        observer.disconnect();
      }
    });
    this.observers.clear();

    // 清理数据引用
    this.dataRefs.clear();
  }

  /**
   * 获取内存使用统计
   * @returns {Object} 统计信息
   */
  getStats() {
    return {
      eventListeners: this.eventListeners.size,
      timers: this.timers.size,
      intervals: this.intervals.size,
      observers: this.observers.size,
      dataRefs: this.dataRefs.size
    };
  }
}

/**
 * Vue混入，用于自动内存管理
 */
export const MemoryManagerMixin = {
  data() {
    return {
      memoryManager: new MemoryManager()
    };
  },

  beforeDestroy() {
    // 自动清理所有资源
    if (this.memoryManager) {
      this.memoryManager.cleanup();
      this.memoryManager = null;
    }
  }
};

/**
 * 创建内存管理实例
 * @returns {MemoryManager} 内存管理器实例
 */
export function createMemoryManager() {
  return new MemoryManager();
}

export default MemoryManager;
